package com.upbos.upm.module;

import com.upbos.core.util.StringPool;
import com.upbos.data.core.SingleDao;
import com.upbos.data.persistence.Where;
import com.upbos.upm.entity.App;
import com.upbos.upm.entity.Module;
import com.upbos.upm.entity.ModuleRes;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * <b>Application name：</b> ModuleDao.java <br>
 * <b>Application describing： 资源dao</b> <br>
 * <b>Copyright：</b> Copyright &copy; 2018 upbos.com 版权所有。<br>
 * <b>Company：</b> upbos.com <br>
 * <b>Date：</b> 2018年10月06日 10:28 <br>
 * <b>author：</b> <a href="mailto:wangjz@miyzh.com"> wangjz </a> <br>
 * <b>version：</b>V4.2.0 <br>
 */
@Service
public class ModuleDao {

    @Resource
    private SingleDao singleDao;

    /**
     * 获取应用列表
     * @return 应用列表
     */
    public List<App> listApp() {
        return singleDao.queryList("ModuleDaoMapper.listApp");
    }

    /**
     * 获取所有功能模块的列表
     * @return 功能模块列表
     */
    public List<Module> listAllModule() {
        return singleDao.queryList("ModuleDaoMapper.listAllModule");
    }

    /**
     * 获取功能模块对象
     * @param id 功能模块id
     * @return 功能模块对象
     */
    public Module getModule(String id) {
        Module destModule = singleDao.queryOne("ModuleDaoMapper.getModule", id);
        // 如果没有记录，则认为是根节点
        if (destModule == null) {
            destModule = new Module();
            destModule.setId("0");
            destModule.setCascade("0");
        }
        return destModule;
    }

    /**
     * 根据上级节点Id获取功能模块列表
     * @param parentId 上级节点id
     * @return 功能模块列表
     */
    public List<Module> listModuleByParentId(String parentId) {
        return singleDao.queryList("ModuleDaoMapper.listModule", parentId);
    }

    /**
     * 获取功能模块层级
     * @param moduleId 功能模块id
     * @return 功能模块层级
     */
    public String getModuleCascade(String moduleId) {
        Module p = new Module();
        p.setId(moduleId);
        Module module = singleDao.queryOne("ModuleDaoMapper.getModule", p);
        return module == null ? "" : module.getCascade();
    }

    /**
     * 更新功能模块的层级
     * @param oldCascade 原来的层级
     * @param newCascade 更新后的层级
     */
    public void updateCascade(String oldCascade, String newCascade) {
        Map<String, Object> p = new HashMap<>(3);
        p.put("newCascade", newCascade);
        p.put("oldCascade", oldCascade);
        p.put("oldCascadeLength", oldCascade.length() + 1);
        singleDao.update("ModuleDaoMapper.updateCascade", p);
    }

    /**
     * 插入功能模块
     * @param module 功能模块
     */
    public void insertModule(Module module) {
        singleDao.insert(module);
        String parentModuleCascade = getModuleCascade(module.getParentId());
        module.setCascade(parentModuleCascade + (StringPool.EMPTY.equals(parentModuleCascade) ? StringPool.EMPTY: StringPool.DOT) + module.getId());
        singleDao.updateById(module);
    }

    /**
     * 更新功能模块
     * @param module 功能模块
     */
    public void updateModule(Module module) {
        singleDao.updateById(module);
    }


    /**
     * 根据层级删除功能模块
     * @param cascade 层级
     */
    public void deleteModule(String cascade) {
        Module module = new Module();
        module.setCascade(cascade);
        singleDao.delete(module, new Where("cascade_ like concat(#{cascade}, '%')"));
    }

    /**
     * 获取某节点下排序号最大的节点
     *
     * @param parentId 某节点
     * @return 排序号最大的节点
     */
    public Module getMaxIdxModule(String parentId) {
        return singleDao.queryOne("ModuleDaoMapper.getMaxIdxModule", parentId);
    }

    /**
     * 获取功能模块所属的资源列表
     * @param moduleId 功能模块id
     * @return 资源列表
     */
    public List<ModuleRes> listModuleRes(String moduleId) {
        return singleDao.queryList("ModuleDaoMapper.listModuleRes", moduleId);
    }

    /**
     * 根据功能模块层级删除资源
     * @param cascade 功能模块层级
     */
    public void deleteModuleRes(String cascade) {
        // 删除该功能模块所属资源
        singleDao.delete("ModuleDaoMapper.deleteModuleRes", cascade);
    }

    /**
     * 插入功能模块的资源列表
     * @param moduleId 功能模块id
     * @param moduleResList 资源列表
     */
    public void insertModuleRes(String moduleId, List<ModuleRes> moduleResList) {
        // 插入资源
        moduleResList.forEach(res -> res.setModuleId(moduleId));
        singleDao.batchInsert(moduleResList);
    }
}
